package com.hua.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hua.mapper.CommentMapper;
import com.hua.pojo.Canteen;
import com.hua.pojo.Comment;
import com.hua.pojo.Food;
import com.hua.mapper.FoodMapper;
import com.hua.pojo.User;
import com.hua.service.FoodService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author hua
 * @since 2023-12-24
 */
@Slf4j
@Service
public class FoodServiceImpl extends ServiceImpl<FoodMapper, Food> implements FoodService {


    @Autowired
    private FoodMapper foodMapper;
    @Autowired
    private CommentMapper commentMapper;


    //获取全部的菜品信息展示的
    @Override
    public Map<String, Object> getFoodList(int pageNo, int pageSize, int canteenId, int foodClassId) {

        //多条件查询
        LambdaQueryWrapper<Food> wrapper=new LambdaQueryWrapper<>();
        //添加查询条件
        wrapper.eq(Food::getCanteenId,canteenId);//饭堂id
        wrapper.eq(Food::getFoodClassId,foodClassId);//类别id

        // 创建分页对象
        Page<Food> page = new Page<>(pageNo, pageSize);
        // 执行查询并获取结果
        page(page, wrapper); // 使用分页查询方法
        List<Food> foodList = page.getRecords();


        // 创建结果 Map 对象，包含总数和数据列表
        Map<String, Object> data = new HashMap<>();
        data.put("total", page.getTotal());
        data.put("rows", foodList);

        return data;
    }


    //无标签随机
    @Override
    public Map<String, Object> getRandomFood() {


        Food food = foodMapper.getRandomFood();

        // 创建结果 Map 对象
        Map<String, Object> data = new HashMap<>();
        data.put("data", food);

        return data;
    }
    //根据tags分组，再随机生成菜品
    @Override
    public Map<String, Object> getRandomFoodWithTabs(String tags) {


        Food randomFood = this.foodMapper.getRandomFoodWithTabs(tags);


        if(randomFood ==null){//该标签下无结果
            return null;
        }
        // 创建结果 Map 对象
        Map<String, Object> data = new HashMap<>();
        data.put("data", randomFood);

        return data;
    }

    //此接口返回所有的菜品标签，以供随机菜单选择
    @Override
    public List<String> getAllTags() {


        List<String> tagsList = new ArrayList<>();

        //所有的数据
        List<Food> foodList = this.baseMapper.selectList(null);


        // 遍历 Food 对象列表，提取 tags 字段值
        for (Food food : foodList) {
            String tags = food.getTags();
            if (tags != null && !tags.isEmpty() && !tags.equals("<null>")) {
            // 使用 trim() 去除可能的空格
                tagsList.add(tags.trim());
            }
        }

        return tagsList;
    }

    //根据菜品id获取菜品信息
    @Override
    public Map<String, Object> getFoodInfoById(int id) {
        Food food = this.baseMapper.selectById(id);


        // 创建结果 Map 对象，包含总数和数据列表
        Map<String, Object> data = new HashMap<>();
        data.put("data", food);
        return data;
    }

    //首页-菜品搜索API
    @Override
    public Map<String, Object> searchFood(int category, String data) {

        if(category==1){//①以菜名搜索
            //多条件查询
            LambdaQueryWrapper<Food> wrapper1=new LambdaQueryWrapper<>();
            //添加查询条件
            //wrapper1.eq(Food::getTitle,data);//food名称
            wrapper1.like(Food::getTitle,"%"+data+"%");
            List<Food> foodList = this.baseMapper.selectList(wrapper1);

            if(foodList==null){//无结果
                return null;
            }else{
                // 创建结果 Map 对象
                Map<String, Object> data1 = new HashMap<>();
                data1.put("data", foodList);
                return data1;
            }

        }else if(category==2){//②以最低评分搜索符合的，检索出符合输入的最低评分
            //多条件查询
            LambdaQueryWrapper<Food> wrapper2=new LambdaQueryWrapper<>();
            //添加查询条件
            wrapper2.ge(Food::getComment,data);//检索出大于等于输入的评分
            List<Food> foodList = this.baseMapper.selectList(wrapper2);

            if(foodList.isEmpty()){//无结果
                return null;
            }else{
                // 创建结果 Map 对象
                Map<String, Object> data1 = new HashMap<>();
                data1.put("data", foodList);
                return data1;
            }

        }else if(category==3) {//③以饭堂名称搜索,需要多表查询

            Map<String, Object> foodList = selectFoodByCanteenName(data);
            return foodList;//直接返回，因为selectFoodByCanteenName方法已经做了非空的处理

        }else if(category==4) {//④以最高价格搜索符合的，检索出符合输入的最高价格的所有菜品
            //多条件查询
            LambdaQueryWrapper<Food> wrapper4=new LambdaQueryWrapper<>();
            //添加查询条件
            wrapper4.le(Food::getPrice,data);//检索出大于等于输入的价格
            wrapper4.orderByDesc(Food::getPrice);//价格降序
            List<Food> foodList = this.baseMapper.selectList(wrapper4);

            if(foodList.isEmpty()){//无结果
                return null;
            }else{
                // 创建结果 Map 对象
                Map<String, Object> data1 = new HashMap<>();
                data1.put("data", foodList);
                return data1;
            }

        }
        return null;
    }

    //该方法是因为根据饭堂名称查询需要用到多表查询，所以就不用mybatis-plus的查询语句，用mybatis的
    @Override
    public Map<String, Object> selectFoodByCanteenName(String data) {
        List<Food> foodList = foodMapper.selectFoodByCanteenName(data);

        if(foodList.isEmpty()){
            return null;
        }else{
            // 创建结果 Map 对象
            Map<String, Object> data1 = new HashMap<>();
            data1.put("data", foodList);
            return data1;
        }
    }




























    /**
     *     //管理端——根据菜品id列表批量删除菜品
     * @param idArray
     * @return
     */
    @Override
    public Map<String, Object> deleteFoodByIds(String[] idArray) {

        // 执行批量删除操作
        Map<String, Object> data = new HashMap<>();
        //LambdaQueryWrapper<Comment> wrapper = new LambdaQueryWrapper<>();


        for (String id : idArray) {
            // 添加条件
            LambdaQueryWrapper<Comment> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(Comment::getFoodId, id);//对该菜品id的相关评论也一起删除
            int delete = commentMapper.delete(wrapper);
//            try {
//                Thread.sleep(100); // 延时0.1秒
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }

            // 根据菜品ID执行删除操作
            int deleted = this.baseMapper.deleteById(id);



            if (deleted==1) {
                data.put(id, "删除成功");
            } else {
                data.put(id, "删除失败");
            }
        }

        return data;
    }

    /**
     *   //管理端——修改菜品信息
     * @param food
     * @return
     */
    @Override
    public Map<String, Object> modifyFood(Food food) {
        int i = this.foodMapper.updateById(food);
        //
        Map<String, Object> data = new HashMap<>();
        if(i==1){
            data.put("data","修改成功！");
            return data;
        }else{
            return null;
        }
    }


    /**
     *  //管理端——新增菜品信息
     * @param food
     * @return
     */
    @Override
    public Map<String, Object> addFood(Food food) {
        int i = this.foodMapper.insert(food);
        //
        Map<String, Object> data = new HashMap<>();
        if(i==1){
            data.put("data","新增成功！");
            return data;
        }else{
            return null;
        }
    }



    //管理端——删除类别的时候，需要对该类别的food的类别id进行更新到未分类中
    /**
     *
     * @param classId 需要修改的id
     * @param id  修改后的id
     */
    @Override
    public int updateClassIdToDefaultValue(String classId, int id) {
        // 条件符合：类id == classId
        LambdaQueryWrapper<Food> wrapper = new LambdaQueryWrapper<>();
        // 添加查询条件
        wrapper.eq(Food::getFoodClassId, classId);

        // 设置更新的字段和值
        Food updateFood = new Food();
        updateFood.setFoodClassId(id);

        // 执行更新操作,并返回更新的影响条数
        return foodMapper.update(updateFood, wrapper);
    }


}
